ಸುಧಾರಿತ NumPy array indexing ತಂತ್ರಗಳೊಂದಿಗೆ NumPy ಯ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಿ. ಸಮರ್ಥ ಡೇಟಾ ಆಯ್ಕೆಗಾಗಿ boolean indexing, fancy indexing, ಮತ್ತು slicing ಕಲಿಯಿರಿ.
NumPy Array Indexing: ಸುಧಾರಿತ ಆಯ್ಕೆ ತಂತ್ರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು
ಪೈಥಾನ್‌ನಲ್ಲಿ ವೈಜ್ಞಾನಿಕ ಕಂಪ್ಯೂಟಿಂಗ್‌ನ ಮೂಲಾಧಾರವಾದ NumPy, ದೊಡ್ಡ, ಬಹು-ಆಯಾಮದ arrays ಮತ್ತು matrices ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಪ್ರಬಲ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಮೂಲಭೂತ indexing ಮತ್ತು slicing ನಿರ್ಣಾಯಕವಾಗಿದ್ದರೂ, NumPy ಅನ್ನು ನಿಜವಾಗಿಯೂ ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ಅದರ ಸುಧಾರಿತ ಆಯ್ಕೆ ತಂತ್ರಗಳನ್ನು ಆಳವಾಗಿ ಪರಿಶೀಲಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಈ ವಿಧಾನಗಳು ಅತ್ಯಾಧುನಿಕ ಡೇಟಾ ನಿರ್ವಹಣೆಗೆ ಅವಕಾಶ ನೀಡುತ್ತವೆ, ಬಳಕೆದಾರರಿಗೆ ಅಗತ್ಯವಿರುವ ಮಾಹಿತಿಯನ್ನು ಗಮನಾರ್ಹ ದಕ್ಷತೆಯೊಂದಿಗೆ ನಿಖರವಾಗಿ ಹೊರತೆಗೆಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ. ಈ ಪೋಸ್ಟ್ ನಿಮಗೆ boolean indexing ಮತ್ತು fancy indexing ನ ಸೂಕ್ಷ್ಮತೆಗಳ ಮೂಲಕ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ, ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಒಳನೋಟಗಳನ್ನು ನೀಡುತ್ತದೆ.
ಅಡಿಪಾಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು: ಮೂಲಭೂತ Indexing ಮತ್ತು Slicing
ನಾವು ಸುಧಾರಿತ ಕ್ಷೇತ್ರಕ್ಕೆ ಕಾಲಿಡುವ ಮೊದಲು, ಮೂಲಭೂತ indexing ಮತ್ತು slicing ಬಗ್ಗೆ ಸಂಕ್ಷಿಪ್ತ ಮರುಪರಿಶೀಲನೆ ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ. 1D array ಗಾಗಿ, indexing ನೇರವಾಗಿರುತ್ತದೆ: arr[i] index i ನಲ್ಲಿರುವ ಅಂಶವನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ. Slicing, arr[start:stop:step] ಎಂಬ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಅಂಶಗಳ ಶ್ರೇಣಿಯನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಬಳಸುತ್ತದೆ.
2D arrays ಗಾಗಿ, indexing, ಸಾಲುಗಳು ಮತ್ತು ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವವರೆಗೆ ವಿಸ್ತರಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, arr[row, column] ನಿರ್ದಿಷ್ಟ ಅಂಶವನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ. Slicing ಅನ್ನು ಸಾಲುಗಳು ಮತ್ತು ಕಾಲಮ್‌ಗಳಿಗೆ ಸ್ವತಂತ್ರವಾಗಿ ಅನ್ವಯಿಸಬಹುದು: arr[row_slice, column_slice].
ಸರಳವಾದ 2D array ಅನ್ನು ಪರಿಗಣಿಸಿ:
import numpy as np
arr_2d = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# Accessing an element
print(arr_2d[1, 2]) # Output: 6
# Slicing rows and columns
print(arr_2d[0:2, 1:3])
# Output:
# [[2 3]
# [5 6]]
ಪರಿಣಾಮಕಾರಿಯಾಗಿದ್ದರೂ, ಸಂಕೀರ್ಣ ಆಯ್ಕೆ ಮಾನದಂಡಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಈ ವಿಧಾನಗಳು ಭಾರವಾಗಬಹುದು. ಇಲ್ಲಿ ಸುಧಾರಿತ indexing ತಂತ್ರಗಳು ಪ್ರಜ್ವಲಿಸುತ್ತವೆ.
Boolean Indexing: ಷರತ್ತುಗಳ ಆಧಾರದ ಮೇಲೆ ಡೇಟಾವನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು
Boolean indexing, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಷರತ್ತುಬದ್ಧ ಆಯ್ಕೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಇದು boolean ಷರತ್ತಿನ ಆಧಾರದ ಮೇಲೆ array ನಿಂದ ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಡೇಟಾವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಇದು ನಂಬಲಾಗದಷ್ಟು ಪ್ರಬಲ ತಂತ್ರವಾಗಿದೆ. ನೀವು ಮೂಲ array ನಂತೆಯೇ ಅದೇ ಆಕಾರದ boolean array ಅನ್ನು ರಚಿಸುತ್ತೀರಿ, ಅಲ್ಲಿ True ಅನುಗುಣವಾದ ಅಂಶವನ್ನು ಆಯ್ಕೆ ಮಾಡಬೇಕೆಂದು ಸೂಚಿಸುತ್ತದೆ, ಮತ್ತು False ಹೊರಗಿಡುವಿಕೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ.
ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ
ಪ್ರಕ್ರಿಯೆಯು ಸಾಮಾನ್ಯವಾಗಿ array ಮೇಲೆ ಹೋಲಿಕೆ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಈ ಕಾರ್ಯಾಚರಣೆಯು boolean array ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ನಂತರ ನೀವು ಈ boolean array ಅನ್ನು ಮೂಲ array ಅನ್ನು index ಮಾಡಲು ಬಳಸುತ್ತೀರಿ.
ಉದಾಹರಣೆ 1: ಮೌಲ್ಯಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು
ನಿಮ್ಮಲ್ಲಿ ಜಾಗತಿಕ ತಾಪಮಾನಗಳ ಡೇಟಾಸೆಟ್ ಇದೆ ಮತ್ತು ತಾಪಮಾನವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಮಿತಿಯನ್ನು ಮೀರಿದ ಎಲ್ಲಾ ದಿನಗಳನ್ನು ನೀವು ಗುರುತಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಭಾವಿಸೋಣ.
# Assume a 1D array of temperatures from various cities worldwide
temperatures = np.array([25.5, 31.2, 18.9, 28.7, 22.1, 35.0, 15.6])
# Set a threshold
threshold = 28.0
# Create a boolean mask
high_temperatures_mask = temperatures > threshold
print(high_temperatures_mask)
# Output: [False True False True False True False]
# Use the mask to select elements
hot_days = temperatures[high_temperatures_mask]
print(hot_days)
# Output: [31.2 28.7 35. ]
ಇದು 28.0 ಡಿಗ್ರಿಗಿಂತ ಹೆಚ್ಚಿನ ಎಲ್ಲಾ ತಾಪಮಾನಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ. ಔಟ್‌ಪುಟ್ ಒಂದು ಹೊಸ 1D array ಆಗಿದ್ದು, ಷರತ್ತನ್ನು ಪೂರೈಸಿದ ಮೌಲ್ಯಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿದೆ.
ಉದಾಹರಣೆ 2: 2D Arrays ನೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದು
Boolean indexing ಅನ್ನು ಬಹು-ಆಯಾಮದ arrays ಗೂ ಅನ್ವಯಿಸಬಹುದು. 2D array ನೊಂದಿಗೆ ಬಳಸಿದಾಗ, ಅದೇ ಆಕಾರದ boolean mask, mask True ಆಗಿರುವ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡ 1D array ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
# A 2D array representing sales figures for different products across regions
sales_data = np.array([[150, 200, 120],
[300, 180, 250],
[90, 220, 160]])
# Identify sales figures above a certain target
target_sales = 200
# Create a boolean mask
successful_sales_mask = sales_data >= target_sales
print(successful_sales_mask)
# Output:
# [[False True False]
# [ True False True]
# [False True False]]
# Select the corresponding sales figures
selected_sales = sales_data[successful_sales_mask]
print(selected_sales)
# Output: [200 300 250 220]
ಇದು ಗುರಿಯನ್ನು ತಲುಪಿದ ಅಥವಾ ಮೀರಿದ ಎಲ್ಲಾ ಮಾರಾಟದ ಅಂಕಿಅಂಶಗಳ 1D array ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸ್ಪಷ್ಟವಾದ ಲೂಪ್‌ಗಳಿಲ್ಲದೆ ಬಹುಆಯಾಮದ ಡೇಟಾವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಇದು ಪ್ರಬಲ ಮಾರ್ಗವಾಗಿದೆ.
ಬಹು ಷರತ್ತುಗಳೊಂದಿಗೆ Boolean Indexing
ತಾರ್ಕಿಕ ಆಪರೇಟರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಬಹು boolean ಷರತ್ತುಗಳನ್ನು ಸಂಯೋಜಿಸಬಹುದು:
&: ಅಂಶ-ವಾರು ತಾರ್ಕಿಕ AND|: ಅಂಶ-ವಾರು ತಾರ್ಕಿಕ OR~: ಅಂಶ-ವಾರು ತಾರ್ಕಿಕ NOT
ಪ್ರಮುಖ ಸೂಚನೆ: ಷರತ್ತುಗಳನ್ನು ಸಂಯೋಜಿಸುವಾಗ, Python ನ ಆಪರೇಟರ್ ಆದ್ಯತೆಯ ಕಾರಣದಿಂದಾಗಿ ಪ್ರತಿಯೊಂದು ವೈಯಕ್ತಿಕ ಷರತ್ತನ್ನು ಆವರಣಗಳಲ್ಲಿ ಸುತ್ತುವರಿಯಬೇಕು.
# Select sales figures that are between 150 and 250 (inclusive)
condition_low = sales_data >= 150
condition_high = sales_data <= 250
between_150_and_250 = sales_data[condition_low & condition_high]
print(between_150_and_250)
# Output: [150 200 180 250 220 160]
ಇದು ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯೊಳಗೆ ಬರುವ ಡೇಟಾವನ್ನು ಹೇಗೆ ಹೊರತೆಗೆಯುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ, ಇದು ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಯಲ್ಲಿ ಸಾಮಾನ್ಯ ಕಾರ್ಯವಾಗಿದೆ.
Fancy Indexing: ಪೂರ್ಣಾಂಕ Arrays ಬಳಸಿಕೊಂಡು ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು
Fancy indexing ಎನ್ನುವುದು ಮತ್ತೊಂದು ಸುಧಾರಿತ ಆಯ್ಕೆ ತಂತ್ರವಾಗಿದ್ದು, ಪೂರ್ಣಾಂಕಗಳ arrays ಬಳಸಿಕೊಂಡು ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು slicing ನಿಂದ ಭಿನ್ನವಾಗಿದೆ, ಇದು ಡೇಟಾದ ಸತತ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ. Fancy indexing ಅವುಗಳ ಸೂಚ್ಯಂಕಗಳ ಆಧಾರದ ಮೇಲೆ array ನಿಂದ ಅನಿಯಂತ್ರಿತ ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ
ನೀವು indexing ಆಪರೇಟರ್‌ಗೆ ಸೂಚ್ಯಂಕಗಳ array ಅನ್ನು ಒದಗಿಸುತ್ತೀರಿ. ನಂತರ NumPy ಹೊಸ array ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಅಂಶಗಳು ಒದಗಿಸಿದ ಸೂಚ್ಯಂಕಗಳ ಪ್ರಕಾರ ಕ್ರಮಬದ್ಧವಾಗಿರುತ್ತವೆ.
ಉದಾಹರಣೆ 1: 1D Array ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು
ನಿಮ್ಮಲ್ಲಿ ಬಳಕೆದಾರರ ID ಗಳ ಪಟ್ಟಿ ಇದೆ ಮತ್ತು ನೀವು ನಿರ್ದಿಷ್ಟ ಬಳಕೆದಾರರಿಗಾಗಿ ಮಾತ್ರ ಡೇಟಾವನ್ನು ಹಿಂಪಡೆಯಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಊಹಿಸಿಕೊಳ್ಳಿ.
# A list of sample user IDs
user_ids = np.array([101, 105, 110, 102, 115, 108])
# Indices of the users we are interested in
selected_indices = np.array([0, 3, 5]) # Corresponds to user IDs at index 0, 3, and 5
# Select the data for these users
selected_users = user_ids[selected_indices]
print(selected_users)
# Output: [101 102 108]
ಇದು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸೂಚ್ಯಂಕಗಳಲ್ಲಿರುವ user_ids ಅನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುವ ಹೊಸ array ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ 2: 2D Arrays ನೊಂದಿಗೆ Fancy Indexing
ಬಹು-ಆಯಾಮದ arrays ನೊಂದಿಗೆ Fancy indexing ವಿಶೇಷವಾಗಿ ಪ್ರಬಲವಾಗುತ್ತದೆ. 2D array ಅನ್ನು index ಮಾಡಲು ನೀವು ಪೂರ್ಣಾಂಕ arrays ಬಳಸಿದಾಗ, ನೀವು ನಿರ್ದಿಷ್ಟ ಸಾಲುಗಳು, ಕಾಲಮ್‌ಗಳು ಅಥವಾ ಪ್ರತ್ಯೇಕ ಅಂಶಗಳನ್ನು ನಾನ್-ಕಾಂಟಿಗ್ಯೂಯಸ್ ರೀತಿಯಲ್ಲಿ ಆಯ್ಕೆ ಮಾಡಬಹುದು.
2D arrays ನೊಂದಿಗೆ fancy indexing ಬಳಸಲು ಎರಡು ಪ್ರಾಥಮಿಕ ಮಾರ್ಗಗಳಿವೆ:
- ಸಾಲುಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು: ಸಾಲು ಸೂಚ್ಯಂಕಗಳ 1D array ಅನ್ನು ಒದಗಿಸಿ.
- ನಿರ್ದಿಷ್ಟ ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು (ಸಾಲು, ಕಾಲಮ್ ಜೋಡಿಗಳು): ಸೂಚ್ಯಂಕಗಳ ಎರಡು 1D arrays ಅನ್ನು ಒದಗಿಸಿ – ಒಂದು ಸಾಲುಗಳಿಗಾಗಿ ಮತ್ತು ಒಂದು ಕಾಲಮ್‌ಗಳಿಗಾಗಿ. ಈ arrays ಒಂದೇ ಉದ್ದವನ್ನು ಹೊಂದಿರಬೇಕು, ಮತ್ತು ಸಾಲು ಸೂಚ್ಯಂಕ array ನ i-ನೇ ಅಂಶ ಮತ್ತು ಕಾಲಮ್ ಸೂಚ್ಯಂಕ array ನ i-ನೇ ಅಂಶವು ಆಯ್ಕೆ ಮಾಡಬೇಕಾದ ಒಂದು ಅನನ್ಯ ಅಂಶವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
ನಿರ್ದಿಷ್ಟ ಸಾಲುಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು
ಹಲವಾರು ದಿನಗಳಲ್ಲಿ ವಿವಿಧ ಕಂಪನಿಗಳ ಷೇರು ಬೆಲೆಗಳ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಪರಿಗಣಿಸೋಣ. ನಾವು ನಿರ್ದಿಷ್ಟ ಕಂಪನಿಗಳ ಡೇಟಾವನ್ನು ಹಿಂಪಡೆಯಲು ಬಯಸುತ್ತೇವೆ.
# Stock prices for 3 companies over 4 days
# Rows represent days, columns represent companies
stock_prices = np.array([[100, 150, 200],
[105, 152, 205],
[110, 155, 210],
[115, 160, 215]])
# Indices of the companies we want to examine (e.g., company at index 0 and company at index 2)
company_indices = np.array([0, 2])
# Select the data for these companies across all days
selected_companies_data = stock_prices[:, company_indices]
print(selected_companies_data)
# Output:
# [[100 200]
# [105 205]
# [110 210]
# [115 215]]
ಇಲ್ಲಿ, : ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ, ಮತ್ತು company_indices ನಿರ್ದಿಷ್ಟ ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ. ಫಲಿತಾಂಶವು ಒಂದು ಹೊಸ 2D array ಆಗಿದ್ದು, ಅಲ್ಲಿ ಪ್ರತಿ ಕಾಲಮ್ ಆಯ್ಕೆಮಾಡಿದ ಕಂಪನಿಗಳಿಗೆ ಅನುಗುಣವಾಗಿರುತ್ತದೆ.
ಸಾಲು ಮತ್ತು ಕಾಲಮ್ ಜೋಡಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಿರ್ದಿಷ್ಟ ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು
ಇಲ್ಲಿ fancy indexing ಹೆಚ್ಚಿನ ನಮ್ಯತೆಯನ್ನು ನೀಡುತ್ತದೆ. ನೀವು ಅನಿಯಂತ್ರಿತ ಅಂಶಗಳನ್ನು ಅವುಗಳ ಸಾಲು ಮತ್ತು ಕಾಲಮ್ ಸೂಚ್ಯಂಕಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಮೂಲಕ ಗುರುತಿಸಬಹುದು.
# A grid representing population density across different zones and sectors
population_density = np.array([[1000, 1200, 800, 1500],
[900, 1100, 750, 1400],
[1300, 1400, 950, 1600],
[850, 1050, 700, 1350]])
# We want to check the density at specific zone-sector combinations.
# Let's say we are interested in:
# - Zone 0, Sector 1 (row 0, col 1)
# - Zone 2, Sector 0 (row 2, col 0)
# - Zone 1, Sector 3 (row 1, col 3)
# - Zone 3, Sector 2 (row 3, col 2)
row_indices = np.array([0, 2, 1, 3])
column_indices = np.array([1, 0, 3, 2])
# Select the population densities at these specific locations
specific_locations_density = population_density[row_indices, column_indices]
print(specific_locations_density)
# Output: [1200 1300 1400 700]
ಔಟ್‌ಪುಟ್ ಒಂದು 1D array ಆಗಿದ್ದು, ಸೂಚ್ಯಂಕಗಳ ಜೋಡಿಗಳಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ನಿಖರವಾದ ನಿರ್ದೇಶಾಂಕಗಳಲ್ಲಿ ಜನಸಂಖ್ಯಾ ಸಾಂದ್ರತೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ಪ್ರಮುಖ ಒಳನೋಟ: ಔಟ್‌ಪುಟ್ array ನ ಆಕಾರವು ಸೂಚ್ಯಂಕ arrays ನ ಆಕಾರದಿಂದ ನಿರ್ಧರಿಸಲ್ಪಡುತ್ತದೆ. ಎರಡೂ ಸೂಚ್ಯಂಕ arrays 1D ಆಗಿದ್ದು, ಒಂದೇ ಉದ್ದ N ಹೊಂದಿದ್ದರೆ, ಔಟ್‌ಪುಟ್ N ಉದ್ದದ 1D array ಆಗಿರುತ್ತದೆ. ಸೂಚ್ಯಂಕ arrays ಗಳಲ್ಲಿ ಒಂದು ಬಹು-ಆಯಾಮದ್ದಾಗಿದ್ದರೆ, ಔಟ್‌ಪುಟ್ array ಆ ಆಕಾರವನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತದೆ.
Fancy Indexing ಮತ್ತು Broadcasting
ವಿಭಿನ್ನ ಆಕಾರಗಳನ್ನು ಹೊಂದಿರುವ ಬಹು ಸೂಚ್ಯಂಕ arrays ನೊಂದಿಗೆ fancy indexing ಬಳಸುವಾಗ, NumPy ಯ broadcasting ನಿಯಮಗಳು ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ನೀವು 2D array ಅನ್ನು ಸಾಲುಗಳಿಗಾಗಿ 1D array ನೊಂದಿಗೆ ಮತ್ತು ಕಾಲಮ್‌ಗಳಿಗಾಗಿ ಒಂದೇ ಪೂರ್ಣಾಂಕದೊಂದಿಗೆ index ಮಾಡಿದರೆ, broadcasting ಆ ಒಂದೇ ಕಾಲಮ್ ಸೂಚ್ಯಂಕವನ್ನು ಸಾಲುಗಳ ಸಂಖ್ಯೆಗೆ ಹೊಂದಿಸಲು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ವಿಸ್ತರಿಸುತ್ತದೆ.
# Let's select all elements from the first two rows, but only from the third column
indices_rows = np.array([0, 1]) # Indices of rows
index_col = 2 # Index of the column
selected_subset = population_density[indices_rows, index_col]
print(selected_subset)
# Output: [800 750]
ಈ ಸಂದರ್ಭದಲ್ಲಿ, index_col (ಇದು 2) indices_rows ನ ಆಕಾರಕ್ಕೆ (ಇದು (2,)) ಹೊಂದಿಕೆಯಾಗಲು broadcast ಮಾಡಲಾಗುತ್ತದೆ, ಪರಿಣಾಮಕಾರಿಯಾಗಿ index ಜೋಡಿಗಳಾದ (0, 2) ಮತ್ತು (1, 2) ಅನ್ನು ರಚಿಸುತ್ತದೆ.
Boolean ಮತ್ತು Fancy Indexing ಅನ್ನು ಸಂಯೋಜಿಸುವುದು
ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಆಯ್ಕೆ ಮಾದರಿಗಳನ್ನು ರಚಿಸಲು ನೀವು boolean indexing ಮತ್ತು fancy indexing ಅನ್ನು ಸಂಯೋಜಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ನೀವು ಮೊದಲು ಒಂದು ಷರತ್ತಿನ ಆಧಾರದ ಮೇಲೆ ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಬಹುದು ಮತ್ತು ನಂತರ ಆ ಫಿಲ್ಟರ್ ಮಾಡಿದ ಸಾಲುಗಳಿಂದ ನಿರ್ದಿಷ್ಟ ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು fancy indexing ಅನ್ನು ಬಳಸಬಹುದು.
sales_data ಉದಾಹರಣೆಯನ್ನು ಮತ್ತೆ ನೋಡೋಣ:
# sales_data = np.array([[150, 200, 120],
# [300, 180, 250],
# [90, 220, 160]])
# Let's say we only want to consider rows where at least one sale figure is above 200
# Create a boolean mask for rows
# We check if any element in a row is greater than 200
row_mask = np.any(sales_data > 200, axis=1)
print(row_mask)
# Output: [False True True]
# Apply this row mask to select relevant rows
filtered_rows = sales_data[row_mask]
print(filtered_rows)
# Output:
# [[300 180 250]
# [ 90 220 160]]
# Now, from these filtered rows, let's use fancy indexing to select specific columns.
# Suppose we want the first and third columns from these filtered rows.
row_indices_for_fancy = np.array([0, 1]) # Indices within the filtered_rows array
column_indices_for_fancy = np.array([0, 2]) # Indices of columns we want
final_selection = filtered_rows[row_indices_for_fancy, column_indices_for_fancy]
print(final_selection)
# Output: [300 160]
ಈ ಉದಾಹರಣೆಯು ನೀವು ಮೊದಲು ನಿಮ್ಮ ಡೇಟಾವನ್ನು ವಿಶಾಲವಾದ ಷರತ್ತಿನ ಆಧಾರದ ಮೇಲೆ (ಹೆಚ್ಚಿನ ಮಾರಾಟದೊಂದಿಗೆ ಸಾಲುಗಳು) ಫಿಲ್ಟರ್ ಮಾಡಿ ಮತ್ತು ನಂತರ ಆ ಫಿಲ್ಟರ್ ಮಾಡಿದ ಸಾಲುಗಳಿಂದ ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಆಯ್ದುಕೊಳ್ಳುವ ಸನ್ನಿವೇಶವನ್ನು ವಿವರಿಸುತ್ತದೆ.
ಪ್ರಾಯೋಗಿಕ ಅನ್ವಯಗಳು ಮತ್ತು ಜಾಗತಿಕ ದೃಷ್ಟಿಕೋನಗಳು
ಈ ಸುಧಾರಿತ indexing ತಂತ್ರಗಳು ಕೇವಲ ಸೈದ್ಧಾಂತಿಕ ನಿರ್ಮಾಣಗಳಲ್ಲ; ಅವು ಜಗತ್ತಿನಾದ್ಯಂತ ನೈಜ-ಪ್ರಪಂಚದ ಡೇಟಾ ವಿಜ್ಞಾನ ಅನ್ವಯಗಳಲ್ಲಿ ಅನಿವಾರ್ಯ ಸಾಧನಗಳಾಗಿವೆ:
- ಹಣಕಾಸು ವಿಶ್ಲೇಷಣೆ: ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಕಂಪನಿಗಳ ಷೇರು ಬೆಲೆಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು, ಅಥವಾ ಕೆಲವು ಲಾಭದಾಯಕ ಮಿತಿಗಳನ್ನು ಪೂರೈಸಿದ ವ್ಯಾಪಾರಗಳನ್ನು ಗುರುತಿಸುವುದು.
- ಹವಾಮಾನ ವಿಜ್ಞಾನ: ವ್ಯಾಖ್ಯಾನಿತ ಮಾನದಂಡಗಳ ಆಧಾರದ ಮೇಲೆ ನಿರ್ದಿಷ್ಟ ಭೌಗೋಳಿಕ ಪ್ರದೇಶಗಳು ಅಥವಾ ಸಮಯದ ಅವಧಿಗಳಿಗೆ ತಾಪಮಾನ ಅಥವಾ ಮಳೆಯ ಡೇಟಾವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು. ಉದಾಹರಣೆಗೆ, ನಿರ್ದಿಷ್ಟ ಮಳೆಯ ಮಾನದಂಡಕ್ಕಿಂತ ಕಡಿಮೆ ಡೇಟಾವನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ಮೂಲಕ ಬರ ಪೀಡಿತ ಪ್ರದೇಶಗಳನ್ನು (ಉದಾಹರಣೆಗೆ, ಆಸ್ಟ್ರೇಲಿಯಾದ ಭಾಗಗಳು, ಆಫ್ರಿಕಾದ ಸಹೇಲ್ ಪ್ರದೇಶ) ಗುರುತಿಸುವುದು.
- ಇ-ಕಾಮರ್ಸ್: ವಿವಿಧ ಮಾರುಕಟ್ಟೆಗಳಲ್ಲಿ (ಉದಾಹರಣೆಗೆ, ಯುರೋಪ್, ಏಷ್ಯಾ, ಉತ್ತರ ಅಮೆರಿಕಾ) ನಿರ್ದಿಷ್ಟ ಮಾರಾಟ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಹೆಚ್ಚಿನ-ಮೌಲ್ಯದ ಗ್ರಾಹಕರು ಅಥವಾ ಉತ್ಪನ್ನಗಳನ್ನು ಗುರುತಿಸಲು ಗ್ರಾಹಕ ಡೇಟಾವನ್ನು ವಿಭಾಗಿಸುವುದು.
- ಆರೋಗ್ಯ ರಕ್ಷಣೆ: ವೈವಿಧ್ಯಮಯ ಜನಸಂಖ್ಯೆಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಪರಿಸ್ಥಿತಿಗಳು ಅಥವಾ ಚಿಕಿತ್ಸೆಯ ಇತಿಹಾಸಗಳನ್ನು ಹೊಂದಿರುವ ವ್ಯಕ್ತಿಗಳ ದಾಖಲೆಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ರೋಗಿಯ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು.
- ಯಂತ್ರ ಕಲಿಕೆ: ಸಂಕೀರ್ಣ ಮಾನದಂಡಗಳ ಆಧಾರದ ಮೇಲೆ ವೈಶಿಷ್ಟ್ಯಗಳು ಅಥವಾ ಮಾದರಿಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ಮೂಲಕ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಸಿದ್ಧಪಡಿಸುವುದು, ಅಥವಾ ನಿರ್ದಿಷ್ಟ ನಿಯತಾಂಕಗಳಿಗಾಗಿ ಮಾದರಿ ಗುಣಾಂಕಗಳನ್ನು ಹೊರತೆಗೆಯುವುದು.
ಡೇಟಾವನ್ನು ನಿಖರವಾಗಿ ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಆಯ್ಕೆ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವು ನಿಖರವಾದ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಲು, ಅರ್ಥಪೂರ್ಣ ಒಳನೋಟಗಳನ್ನು ಪಡೆಯಲು ಮತ್ತು ಭೌಗೋಳಿಕ ಸ್ಥಳ ಅಥವಾ ಉದ್ಯಮವನ್ನು ಲೆಕ್ಕಿಸದೆ ಮಾಹಿತಿ ಆಧಾರಿತ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಗಣನೆಗಳು
NumPy ಯ ಸುಧಾರಿತ indexing ಅತ್ಯಂತ ಉತ್ತಮಗೊಳಿಸಲಾಗಿದೆ. ಸ್ಪಷ್ಟವಾದ Python ಲೂಪ್‌ಗಳ ಅಗತ್ಯವಿರುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು NumPy ಸಾಮಾನ್ಯವಾಗಿ ವೆಕ್ಟರೈಸ್ ಮಾಡುತ್ತದೆ, ಇದು ಗಮನಾರ್ಹ ಕಾರ್ಯಕ್ಷಮತೆಯ ಲಾಭಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಕೆಲವು ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದು ಮುಖ್ಯ:
- Boolean indexing ಸಾಮಾನ್ಯವಾಗಿ ಆಯ್ಕೆಮಾಡಿದ ಅಂಶಗಳ 1D array ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಕೆಲವು ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಮೂಲ ಆಕಾರವನ್ನು ಉಳಿಸಿಕೊಳ್ಳಲು ನಿಮಗೆ ಅಗತ್ಯವಿದ್ದರೆ, ನೀವು reshape ಮಾಡಬೇಕಾಗಬಹುದು ಅಥವಾ ಇತರ ತಂತ್ರಗಳನ್ನು ಬಳಸಬೇಕಾಗಬಹುದು.
- Fancy indexing ಡೇಟಾದ ನಕಲನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸೂಚ್ಯಂಕ arrays ಪೂರ್ಣಾಂಕಗಳಾಗಿದ್ದರೆ, ಫಲಿತಾಂಶವು ನಕಲು. ಸೂಚ್ಯಂಕ arrays boolean ಆಗಿದ್ದರೆ, ಫಲಿತಾಂಶವು ಸಹ ನಕಲು. ಇದರರ್ಥ ಹಿಂತಿರುಗಿದ array ಗೆ ಮಾಡಿದ ಬದಲಾವಣೆಗಳು ಮೂಲ array ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.
- ಅತ್ಯಂತ ದೊಡ್ಡ arrays ಮತ್ತು ಸಂಕೀರ್ಣ indexing ಯೋಜನೆಗಳಿಗಾಗಿ, ಮೆಮೊರಿ ಬಳಕೆ ಒಂದು ಅಂಶವಾಗಬಹುದು. NumPy ಕಾರ್ಯಾಚರಣೆಗಳು ಮಧ್ಯಂತರ arrays ಅನ್ನು ರಚಿಸುತ್ತವೆ, ಇದು ಮೆಮೊರಿಯನ್ನು ಬಳಸುತ್ತದೆ.
ಕಾರ್ಯಕ್ಷಮತೆ ನಿರ್ಣಾಯಕವಾಗಿದ್ದಾಗ, ವಿಶೇಷವಾಗಿ ಸಮಯ-ಸೂಕ್ಷ್ಮ ಅನ್ವಯಗಳಲ್ಲಿ ಅಥವಾ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವಾಗ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪ್ರೊಫೈಲ್ ಮಾಡುವುದು ಮತ್ತು ಆಧಾರವಾಗಿರುವ NumPy ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ನಿಮಗೆ ಮತ್ತಷ್ಟು ಉತ್ತಮಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇದು boolean ಮತ್ತು fancy indexing ನಡುವೆ ಆಯ್ಕೆ ಮಾಡುವುದನ್ನು, ಅಥವಾ ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಮರುರಚನೆ ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿರಬಹುದು.
ಸುಧಾರಿತ Indexing ಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು
NumPy ಯ ಸುಧಾರಿತ indexing ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಿಕೊಳ್ಳಲು:
- ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ: ಕೋಡ್ ಬರೆಯುವ ಮೊದಲು ಆಯ್ಕೆಗಾಗಿ ಮಾನದಂಡಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಿ.
- ಅರ್ಥಪೂರ್ಣ ವೇರಿಯೇಬಲ್ ಹೆಸರುಗಳನ್ನು ಬಳಸಿ: ನಿಮ್ಮ boolean masks ಮತ್ತು index arrays ಗಳನ್ನು ವಿವರಣಾತ್ಮಕವಾಗಿ ಹೆಸರಿಸಿ (ಉದಾಹರಣೆಗೆ,
high_value_customers_mask,target_product_indices). - ಓದಲು ಸುಲಭವಾಗುವುದಕ್ಕೆ ಆದ್ಯತೆ ನೀಡಿ: ಸಂಕ್ಷಿಪ್ತ ಕೋಡ್ ಉತ್ತಮವಾಗಿದ್ದರೂ, ಇತರರಿಗೆ (ಮತ್ತು ನಿಮ್ಮ ಭವಿಷ್ಯದ ಸ್ವಯಂ) ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಾದ ಕೋಡ್‌ಗೆ ಆದ್ಯತೆ ನೀಡಿ. ಸಂಯೋಜಿತ boolean ಷರತ್ತುಗಳಿಗಾಗಿ ಆವರಣಗಳನ್ನು ಸೂಕ್ತವಾಗಿ ಬಳಸಿ.
- ಹೆಚ್ಚುವರಿಯಾಗಿ ಪರೀಕ್ಷಿಸಿ: ಸಂಕೀರ್ಣ indexing ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಹಂತ ಹಂತವಾಗಿ ನಿರ್ಮಿಸಿ, ಪ್ರತಿ ಹಂತದಲ್ಲಿ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿ.
- NumPy ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಿ: ಸೂಚ್ಯಂಕಗಳು ಅಥವಾ ಮೌಲ್ಯಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ ಷರತ್ತುಬದ್ಧ ಆಯ್ಕೆಗಾಗಿ
np.where()ನಂತಹ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿ, ಅಥವಾ `np.ix_()` ಅನ್ನು ನಿರ್ದಿಷ್ಟ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಉಪಯುಕ್ತವಾಗುವ ಸೂಚ್ಯಂಕ arrays ಗಳಿಂದ ಪೂರ್ಣ ಗ್ರಿಡ್ ಅನ್ನು ರಚಿಸಲು ಬಳಸಿ. - ನಕಲುಗಳು vs. ವೀಕ್ಷಣೆಗಳ ಬಗ್ಗೆ ಗಮನವಿರಲಿ: fancy indexing ಮತ್ತು boolean indexing ಸಾಮಾನ್ಯವಾಗಿ ಮೂಲ ಡೇಟಾದ ವೀಕ್ಷಣೆಗಳಲ್ಲ, ನಕಲುಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ.
ತೀರ್ಮಾನ
NumPy ಯ ಸುಧಾರಿತ array indexing ತಂತ್ರಗಳು, ಅವುಗಳೆಂದರೆ boolean indexing ಮತ್ತು fancy indexing, Python ನಲ್ಲಿ ಅತ್ಯಾಧುನಿಕ ಡೇಟಾ ಆಯ್ಕೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಮೂಲಭೂತವಾಗಿವೆ. ಅವರು ವಿಶ್ವಾದ್ಯಂತ ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳು, ವಿಶ್ಲೇಷಕರು ಮತ್ತು ಸಂಶೋಧಕರಿಗೆ ಅವರಿಗೆ ಅಗತ್ಯವಿರುವ ಡೇಟಾವನ್ನು ನಿಖರವಾಗಿ ಹೊರತೆಗೆಯಲು ಅಧಿಕಾರ ನೀಡುತ್ತವೆ, ಆಳವಾದ ಒಳನೋಟಗಳು ಮತ್ತು ಹೆಚ್ಚು ದೃಢವಾದ ವಿಶ್ಲೇಷಣೆಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತವೆ. ಈ ತಂತ್ರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನಿಮ್ಮ ಡೇಟಾ-ಚಾಲಿತ ಯೋಜನೆಗಳಿಗಾಗಿ ನೀವು NumPy ಯ ಸಂಪೂರ್ಣ ಶಕ್ತಿಯನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಬಹುದು, ಜಾಗತಿಕ ಹಣಕಾಸು ಮತ್ತು ಹವಾಮಾನ ಸಂಶೋಧನೆಯಿಂದ ವೈಯಕ್ತೀಕರಿಸಿದ ಔಷಧ ಮತ್ತು ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯವರೆಗಿನ ಕ್ಷೇತ್ರಗಳಲ್ಲಿನ ಪ್ರಗತಿಗಳಿಗೆ ಕೊಡುಗೆ ನೀಡಬಹುದು. ನಿಮ್ಮ NumPy ಕಾರ್ಯಪ್ರವಾಹಕ್ಕೆ ಈ ಪ್ರಬಲ ಆಯ್ಕೆ ವಿಧಾನಗಳನ್ನು ಅನ್ವೇಷಿಸುವುದು, ಪ್ರಯೋಗಿಸುವುದು ಮತ್ತು ಸಂಯೋಜಿಸುವುದನ್ನು ಮುಂದುವರಿಸಿ.